#!/usr/bin/env python3
"""
核心业务逻辑 - 用户行为分析
本模块被 consumer.py（本地测试）和 lambda_handler.py（AWS部署）共享
"""

import os
import logging
from typing import Dict, Any

# 导入 LLM 客户端
try:
    from llm_client import LLMClient
    LLM_AVAILABLE = True
except ImportError:
    LLM_AVAILABLE = False
    logging.warning("⚠️  llm_client 未找到，将只使用规则引擎")

logger = logging.getLogger(__name__)


class BehaviorAnalyzer:
    """
    用户行为分析器（支持 LLM + 规则引擎）

    核心功能：
    - 智能路由：根据事件复杂度选择 LLM 或规则引擎
    - 降级策略：LLM 失败时自动降级到规则引擎
    - 结果统一：返回标准化的分析结果
    """

    def __init__(self):
        self.llm_client = None
        self.prompt_template = None

        # 初始化 LLM 客户端
        if LLM_AVAILABLE:
            try:
                self.llm_client = LLMClient()
                if self.llm_client.is_available():
                    # 加载 Prompt 模板
                    self._load_prompt_template()
                    logger.info("✅ LLM 分析器已启用")
                else:
                    logger.info("ℹ️  LLM 未配置，使用规则引擎")
            except Exception as e:
                logger.warning(f"⚠️  LLM 初始化失败: {e}，使用规则引擎")
                self.llm_client = None

    def _load_prompt_template(self):
        """加载 Prompt 模板"""
        try:
            # 使用 V2 版本（意图导向）
            template_path = os.path.join(os.path.dirname(__file__), 'prompt_template_v2.txt')
            with open(template_path, 'r', encoding='utf-8') as f:
                self.prompt_template = f.read()
            logger.info("✅ 已加载 Prompt 模板 V2（意图导向）")
        except Exception as e:
            logger.warning(f"⚠️  加载 Prompt 模板失败: {e}")
            self.prompt_template = None

    def analyze(self, event_data: Dict[str, Any]) -> Dict[str, Any]:
        """
        分析用户行为（智能路由：LLM 或规则引擎）

        Args:
            event_data: 浏览器事件数据

        Returns:
            分析结果，包含:
            {
                'behavior_type': str,        # 行为类型
                'behavior_description': str, # 行为描述
                'confidence': float,         # 置信度 (0-1)
                'analysis_method': str       # 分析方法 (llm/rule_based)
            }
        """
        # 判断是否应该使用 LLM
        should_use_llm = self._should_use_llm(event_data)

        if should_use_llm and self.llm_client and self.prompt_template:
            # 尝试使用 LLM
            try:
                result = self.llm_client.analyze_event(event_data, self.prompt_template)
                if result:
                    logger.debug(f"🤖 使用 LLM 分析: {result['analysis_method']}")
                    return result
            except Exception as e:
                logger.warning(f"⚠️  LLM 分析失败，降级到规则引擎: {e}")

        # 降级到规则引擎
        return self._rule_based_analysis(event_data)

    def _should_use_llm(self, event_data: Dict[str, Any]) -> bool:
        """
        判断是否应该使用 LLM（基于事件复杂度）

        策略：
        - 包含 raw_message（非结构化数据）→ 强制 LLM
        - 有 semanticTree 且长度 > 500 字符 → LLM
        - 有 mutations 且数量 > 0 → LLM
        - 否则 → 规则引擎
        """
        # 如果是原始文本消息，强制使用LLM
        if 'raw_message' in event_data:
            return True

        # 检查是否有复杂的语义树
        global_structure = event_data.get('globalStructure', {})
        semantic_tree = global_structure.get('semanticTree', '')

        if semantic_tree and len(semantic_tree) > 500:
            return True

        # 检查是否有 DOM 变化
        mutation_context = event_data.get('mutationContext', {})
        mutations = mutation_context.get('mutations', [])

        if len(mutations) > 0:
            return True

        # 简单事件用规则引擎
        return False

    def _rule_based_analysis(self, event_data: Dict[str, Any]) -> Dict[str, Any]:
        """基于规则的简单分析（作为LLM的fallback）"""
        event_type = event_data.get('eventType', 'unknown')
        url = event_data.get('url', '')
        user_id = event_data.get('userId', 'unknown')

        # 提取域名
        domain = self._extract_domain(url)

        # 根据事件类型生成描述
        if event_type == 'click':
            behavior_type = 'interaction'

            # 尝试从interactionContext获取目标信息
            context = event_data.get('interactionContext', {})
            selector = context.get('selector', '')

            if 'search' in selector.lower() or 'input' in selector.lower():
                description = f"用户 {user_id} 在 {domain} 点击了搜索框"
            elif 'button' in selector.lower():
                description = f"用户 {user_id} 在 {domain} 点击了按钮"
            elif 'link' in selector.lower() or 'a ' in selector.lower():
                description = f"用户 {user_id} 在 {domain} 点击了链接"
            else:
                event_data_info = event_data.get('eventData', {})
                x = event_data_info.get('clientX', 0)
                y = event_data_info.get('clientY', 0)
                description = f"用户 {user_id} 在 {domain} 点击了位置 ({x}, {y})"

        elif event_type == 'scroll':
            behavior_type = 'navigation'
            scroll_y = event_data.get('eventData', {}).get('scrollY', 0)
            description = f"用户 {user_id} 在 {domain} 滚动到位置 {scroll_y}"

        elif event_type == 'hover':
            behavior_type = 'exploration'
            description = f"用户 {user_id} 在 {domain} 悬停查看内容"

        elif event_type == 'input':
            behavior_type = 'interaction'
            description = f"用户 {user_id} 在 {domain} 输入了内容"

        else:
            behavior_type = 'other'
            description = f"用户 {user_id} 在 {domain} 执行了 {event_type} 操作"

        return {
            'behavior_type': behavior_type,
            'behavior_description': description,
            'confidence': 0.8,  # 规则引擎的置信度
            'analysis_method': 'rule_based'
        }

    def _extract_domain(self, url: str) -> str:
        """提取域名"""
        try:
            from urllib.parse import urlparse
            parsed = urlparse(url)
            return parsed.netloc or 'unknown'
        except:
            return 'unknown'
